#/usr/bin/env python
# -*- coding: utf-8 -*-
#
#	Copyright (C) - 2010	Alexander Ayasca Esquives 
#				<alexander dot uni dot fiis at gmail dot com>
#
#	This file is part of Horarios - UNI
#
#	Horarios - UNI is free software: you can redistribute it and/or modify
#	it under the terms of the GNU General Public License as published by
#	the Free Software Foundation, either version 3 of the License, or
#	(at your option) any later version.

#	Horarios - UNI is distributed in the hope that it will be useful,
#	but WITHOUT ANY WARRANTY; without even the implied warranty of
#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#	GNU General Public License for more details.

#	You should have received a copy of the GNU General Public License
#	along with Foobar.  If not, see <http://www.gnu.org/licenses/>.


################################################################################
# META
################################################################################

__version__ =	"0.9"
__license__ =	"GPL 3"
__author__ =	"Alexander Ayasca Esquives"
__date__ =		"2011-03-20"

################################################################################
# IMPORTS
################################################################################

from PyQt4 import QtCore, QtGui
from Horario_gui import Ui_ventanaPrincipal
from about import Ui_about
from pyfpdf.fpdf import FPDF
from os.path import dirname

import sys

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    _fromUtf8 = lambda s: s

class Ventana(QtGui.QMainWindow):
	def __init__(self,parent=None):
		QtGui.QWidget.__init__(self,parent)
		self.ui=Ui_ventanaPrincipal()
		self.ui.setupUi(self)
		#Por defecto
		self.reset();
	
	# Selección del archivo
	def file_dialog(self):
		""" Abre el la ventana de diálogo que permite seleccionar un
			archivo 
			
			@param self.name: Contiene el nombre del archivo leido
		"""
		self.reset()
		fd = QtGui.QFileDialog(self)
		self.name = fd.getOpenFileName()
		if self.name!='':
			self.ui.adelante.setEnabled(True)
		self.ui.name_file.setText(self.name)

	# Acerca de
	def acerca_de(self):
		a=About(self)
		a.show()
		global ventana
		ventana=self.ui
		ventana.centralwidget.setDisabled(True)
	
	# Navegación
	
	def actualiza_navegacion(self):
		""" Actualiza los botones de navegación """
		max =  self.ui.tabWidget.count()-1
		if self.ui.tabWidget.currentIndex()==0:
			self.ui.atras.setDisabled(True)
			self.ui.adelante.setEnabled(True)
		else:
			self.ui.atras.setEnabled(True)
			if self.ui.tabWidget.currentIndex()==max:
				self.ui.adelante.setDisabled(True)
			else:
				self.ui.adelante.setEnabled(True)
		
	def atras(self):
		""" Retrocede una pestaña """
		if self.ui.tabWidget.currentIndex()>0:
			self.ui.tabWidget.setCurrentIndex(self.ui.tabWidget.currentIndex() -1)
			self.actualiza_navegacion()
			self.actualizaDatos()

	def adelante(self):
		""" Avanza una pestaña """
		max =  self.ui.tabWidget.count()-1
		if self.ui.tabWidget.currentIndex()<max:
			self.ui.tabWidget.setCurrentIndex(self.ui.tabWidget.currentIndex() +1)
			self.actualiza_navegacion()
			self.actualizaDatos()
	
	# Actualización de datos

	def actualizaDatos(self):
		""" Actualiza la información mostrada en las pestañas
			
			@param self.secciones: Almacena una lista de todas las
				secciones
			
			@param self.cur: Almacena una lista de los cursos disponibles
		"""
		if self.ui.tabWidget.currentIndex()==1:
			pass
		elif self.ui.tabWidget.currentIndex()==2 and self.name!='':
			# Tercera Pestaña con un archivo leido.
			self.secciones=leer_datos(self.name,self.orden,self.tipo)
						
			# Obtengo una lista de los cursos
			self.cur=lista_cursos(self.secciones)
			
			# Muestro los cursos y secciones
			i=0
			self.max_cur=len(self.cur) # Número máximo de cursos entre los que se escoge
			
			while self.max_cur>0 and i<self.max_cur:
				exec "self.ui.check_"+str(i+1)+ "= QtGui.QCheckBox(self.ui.scrollAreaWidgetContents)"
				exec "self.ui.check_"+str(i+1)+".setText(_fromUtf8(\"\"))"
				exec "self.ui.check_"+str(i+1)+".setObjectName(_fromUtf8(\"check_1\"))"
				exec "self.ui.gridLayout_3.addWidget(self.ui.check_"+str(i+1)+", "+str(2*i)+", 0, 1, 1)"
				exec "self.ui.curso_"+str(i+1)+" = QtGui.QLabel(self.ui.scrollAreaWidgetContents)"
				font = QtGui.QFont()
				font.setFamily(_fromUtf8("Droid Sans"))
				font.setPointSize(10)
				exec "self.ui.curso_"+str(i+1)+".setFont(font)"
				exec "self.ui.curso_"+str(i+1)+".setObjectName(_fromUtf8(\"curso_"+str(i+1)+"\"))"
				exec "self.ui.gridLayout_3.addWidget(self.ui.curso_"+str(i+1)+", "+str(2*i)+", 1, 1, 1)"
				exec "self.ui.nada_"+str(i+1)+" = QtGui.QLabel(self.ui.scrollAreaWidgetContents)"
				exec "sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)"
				sizePolicy.setHorizontalStretch(0)
				sizePolicy.setVerticalStretch(0)
				exec "sizePolicy.setHeightForWidth(self.ui.nada_"+str(i+1)+".sizePolicy().hasHeightForWidth())"
				exec "self.ui.nada_"+str(i+1)+".setSizePolicy(sizePolicy)"
				exec "self.ui.nada_"+str(i+1)+".setMinimumSize(QtCore.QSize(40, 0))"
				exec "self.ui.nada_"+str(i+1)+".setMaximumSize(QtCore.QSize(40, 16777215))"
				exec "self.ui.nada_"+str(i+1)+".setText(_fromUtf8(\"\"))"
				exec "self.ui.nada_"+str(i+1)+".setObjectName(_fromUtf8(\"nada_"+str(i+1)+"\"))"
				exec "self.ui.gridLayout_3.addWidget(self.ui.nada_"+str(i+1)+", "+str(2*i+1)+", 1, 1, 1)"
				exec "self.ui.seccion_"+str(i+1)+" = QtGui.QComboBox(self.ui.scrollAreaWidgetContents)"
				exec "self.ui.seccion_"+str(i+1)+".setMaximumSize(QtCore.QSize(50, 16777215))"
				exec "self.ui.seccion_"+str(i+1)+".setObjectName(_fromUtf8(\"seccion_"+str(i+1)+"\"))"
				exec "self.ui.gridLayout_3.addWidget(self.ui.seccion_"+str(i+1)+", "+str(2*i+1)+", 2, 1, 1)"
				exec "self.ui.curso_"+str(i+1)+".setText(\'* \'+self.cur["+str(i)+"])"
				exec "lista=lista_sec(self.cur["+str(i)+"],self.secciones)"
				exec "self.ui.seccion_"+str(i+1)+".show()"
				exec "self.ui.seccion_"+str(i+1)+".addItem('-')"
				exec "QtCore.QObject.connect(self.ui.check_"+str(i+1)+", QtCore.SIGNAL(_fromUtf8(\"clicked()\")), self.genera_horarios)"	
				exec "QtCore.QObject.connect(self.ui.seccion_"+str(i+1)+", QtCore.SIGNAL(_fromUtf8(\"currentIndexChanged(int)\")), self.genera_horarios)"
				#Agrega secciones
				for j in range(len(lista)):
					exec "self.ui.seccion_"+str(i+1)+".addItem(lista[j])"
				i=i+1
				
			self.ui.formLayout.setLayout(0, QtGui.QFormLayout.FieldRole, self.ui.gridLayout_3)
			self.ui.scrollArea.setWidget(self.ui.scrollAreaWidgetContents)
			QtCore.QMetaObject.connectSlotsByName(self)

	def obtiene_valores(self):
		"""
			Obtiene los valores de las opciones
			
			@var self.check: Almacena una lista que indica que opciones
			han sido marcadas con un check:
			* 0:	deseleccionado
			* 2:	seleccionado
			@var self.check_sec: Almacena una lista de las secciones
				escogidas
		"""

		#Reinicio el valor de self.check_cur y self.check_sec
		self.check_cur=[0]*len(self.cur)
		self.check_sec=[0]*len(self.cur)
		#Obtiene los valores
		for i in range(self.max_cur):
			exec "self.check_cur["+str(i)+"] =self.ui.check_"+str(i+1)+".checkState()"
			exec """if self.check_cur["""+str(i)+"""]==2:
				self.check_sec["""+str(i)+"""] = self.ui.seccion_"""+str(i+1)+""".currentText()"""
	
	def genera_horarios(self):
		"""	Genera los horarios
			
			@var self.horarios: Almacena una lista de los posibles horarios
		"""
		self.obtiene_valores()
		
		self.horarios=[[]]
		cont=0
		for i in self.check_sec: 
			if i==0:
				pass
			elif i==u'-':
				lista_seccion=lista_sec(self.cur[cont],self.secciones) #lista de secciones
				horarios2=[]
				for j in lista_seccion: # Para cada seccion (todas)
					cur_sec=self.cur[cont]+j # Obtengo el cursoSeccion
					
					for horario in self.horarios: # Para cada horario
						cruze=0
						lista_curSec=buscaCurSec(cur_sec,self.secciones) #lista de objetos curSec
						for k in lista_curSec:
							if comprobar_cruze(k,horario):
								cruze=1
						if cruze==0:
							horario2=horario[:]
							horario2.append(k)
							horarios2.append(horario2)
				self.horarios=horarios2

			else:
				cur=self.cur[cont]
				seccion=i 
				horarios2=[]
				
				cur_sec=self.cur[cont]+seccion # Obtengo el cursoSeccion
						
				for horario in self.horarios: # Para cada horario
					cruze=0
					lista_curSec=buscaCurSec(cur_sec,self.secciones) #lista de objetos curSec
					for k in lista_curSec:
						if comprobar_cruze(k,horario):
							cruze=1
					if cruze==0:
						horario2=horario[:]
						horario2.append(k)
						horarios2.append(horario2)
				self.horarios=horarios2
			cont=cont+1
		
		self.total=len(self.horarios)
		self.ui.pag.setText('0')
		
		#Invocamos a un método que muestra los horarios
		self.muestra_horarios()
		self.ui.imprimir.setEnabled(True)

	def selecciona_fuente(self):
		"""	Orden de los campos del archivo
		"""
		self.tipo=self.ui.orden.currentIndex()
		if self.ui.orden.currentIndex()==0:
			self.orden = [3,4,12,8,11,5]
		elif self.ui.orden.currentIndex()==1:
			self.name=transforma_archivo_mec(self.name)
			self.orden=[3,6,7,11]
		elif self.ui.orden.currentIndex()==2:
			print 2
	
	def muestra_horarios(self):
		"""	Muestra los horarios obtenidos
		"""
		self.ui.total.setText('/'+str(self.total))
		self.resetTabla()
		self.ui.pag.setText('1')
		self.actualizaTabla()
		# Botones de navegación de horarios
	
	def add_cont(self):
		"""	Avanza al siguiente horario
		"""
		if self.ui.pag.text().toInt()[0]<self.total:
			self.ui.pag.setText(unicode(self.ui.pag.text().toInt()[0]+1))
			self.actualizaTabla()
	
	def res_cont(self):
		"""	Retrocede al horario anterior
		"""
		if self.ui.pag.text().toInt()[0]>1:
			self.ui.pag.setText(unicode(self.ui.pag.text().toInt()[0]-1))
			self.actualizaTabla()
	
	def actualizaTabla(self):
		""" Actualiza los valores de la tabla 'Horario'
		"""
		num=self.ui.pag.text().toInt()[0]-1
		
		self.resetTabla()
		if self.total>0:
			for i in self.horarios[num]:
				lista=buscaCurSec(i.Curso.codigo+i.seccion,self.secciones)
				for j in lista:
					if j.dia=='LU':
						x=0
					elif j.dia=='MA':
						x=1
					elif j.dia=='MI':
						x=2
					elif j.dia=='JU':
						x=3
					elif j.dia=='VI':
						x=4
					elif j.dia=='SA':
						x=5
					for k in range(j.Hora.horai,j.Hora.horaf) :
						self.ui.tabla.setItem(k-8,x,QtGui.QTableWidgetItem(QtCore.QString("%1").arg(i.Curso.codigo+i.seccion)))
		else:
			pass

		if num==0:
			self.ui.atras_hor.setDisabled(True)
			if num>=self.total-1:
				self.ui.adel_hor.setDisabled(True)
			else:
				self.ui.adel_hor.setEnabled(True)
		elif num>0:
			self.ui.atras_hor.setEnabled(True)
			if num>=self.total-1:
				self.ui.adel_hor.setDisabled(True)
			else:
				self.ui.adel_hor.setEnabled(True)		

	def resetTabla(self):
		"""	Reinicia los valores mostrados en la tabla de 'Horario'
		"""
		for j in range(6):
			for k in range(0,14) :
				self.ui.tabla.setItem(k,j,QtGui.QTableWidgetItem(QtCore.QString("%1").arg('')))
		
	def reset(self):
		"""	Reinicia todos los valores utilizados.
		"""
		
		# Orden por defecto del archivo leido
		self.tipo=0
		self.orden=[3,4,12,8,11,5]
		# Pestaña por defecto
		self.ui.tabWidget.setCurrentIndex(0)
		# Navegación por defecto
		self.ui.atras.setDisabled(True)
		self.ui.adelante.setDisabled(True)
		# Archivo selecto en blanco
		self.name=''
		self.ui.name_file.setText(self.name)
		# 
		self.ui.pag.setText('')
		
		self.ui.imprimir.setDisabled(True)
		
		# Cursos a seleccionar en blanco
		try:
			cont=self.ui.gridLayout_3.count()
			while self.ui.gridLayout_3.count()>0:
				i=self.ui.gridLayout_3.takeAt(0)
				m=i.widget()
				m.close()
		except:
			self.ui.gridLayout_3 = QtGui.QGridLayout()
			self.ui.gridLayout_3.setObjectName(_fromUtf8("gridLayout_3"))
		
		# Horarios y Tabla en blanco
		self.horarios=[[]]
		self.total=0
		self.muestra_horarios()
		
		self.ui.atras_hor.setDisabled(True)
		self.ui.adel_hor.setDisabled(True)
	
	def imprimir(self):
		pdf=PDF()
		pdf.alias_nb_pages()
		
		#Por problemas con Unicode
		uM = unicode('Miércoles', 'utf-8')
		sM = uM.encode('iso-8859-1')
		
		uS = unicode('Sábado', 'utf-8')
		sS = uS.encode('iso-8859-1')
		
		cabeceraDeTabla=[' ','Lunes','Martes',sM,'Jueves','Viernes',sS]
		
		horas=['08:00 - 09:00','09:00 - 10:00','11:00 - 12:00',
			'12:00 - 13:00','13:00 - 14:00','14:00 - 14:00','14:00 - 15:00',
			'15:00 - 16:00','16:00 - 17:00','17:00 - 18:00','18:00 - 19:00',
			'19:00 - 20:00','20:00 - 21:00','21:00 - 22:00']
				
		for horario in self.horarios:
			self.resetTabla()
			pdf.add_page()
			pdf.set_font('Helvetica','',12)
			pdf.cell(0,10,'Horario ',0,1)
			pdf.ln(20)
			for col in cabeceraDeTabla:
				pdf.cell(27,7,col,1)
			pdf.ln()
			for curSec in horario:				
				#test¿¿
				lista=buscaCurSec(curSec.Curso.codigo+curSec.seccion,self.secciones)
				for j in lista:
					if j.dia=='LU':
						x=0
					elif j.dia=='MA':
						x=1
					elif j.dia=='MI':
						x=2
					elif j.dia=='JU':
						x=3
					elif j.dia=='VI':
						x=4
					elif j.dia=='SA':
						x=5
					for k in range(j.Hora.horai,j.Hora.horaf) :
						self.ui.tabla.setItem(k-8,x,QtGui.QTableWidgetItem(QtCore.QString("%1").arg(curSec.Curso.codigo+curSec.seccion)))
			for y in range(14):
				pdf.cell(27,6,horas[y],1)
				for x in range(6):
					a=self.ui.tabla.item(y,x).text()
					a1 = unicode(a, 'utf-8')
					a2 = a1.encode('iso-8859-1')
					pdf.cell(27,6,a2,1)
				pdf.ln()
			pdf.ln(10)
			for curSec in horario:
				pdf.cell(0,10,str('  '+curSec.Curso.codigo)+' : '+str(curSec.seccion),0,1)
		out=dirname(str(self.name))+'/Horarios.pdf'
		pdf.output(out,'F')
		self.muestra_horarios()
		
class PDF(FPDF):
	def header(self):
		"""	Encabezado
		"""
		# Logo
		self.image('data/logo_uni.jpg',15,20,20)
		# Arial bold 15
		self.set_font('Helvetica','B',20)
		# Move to the right
		self.ln(12)
		self.cell(75)
		# Title
		self.cell(50,12,'Horario UNI',1,0,'C')
		# Line break
		self.ln(50)

	def footer(self):
		"""	Pie de página
		"""
		# Posicionado a 1.5 cm de la parte inferior
		self.set_y(-15)
		# Helvética itálica 9
		self.set_font('Helvetica','I',9)
		# Número de Página
		self.cell(0,10,'Horario: '+str(self.page_no())+'/{nb}',0,0,'C')		

class About(QtGui.QMainWindow):
	""" Clase que controla a la ventana 'Acerca de'
	"""
	def __init__(self,parent=None):
		QtGui.QWidget.__init__(self,parent)
		self.ui=Ui_about()
		self.ui.setupUi(self)
		
	def closeEvent(self, e):
		ventana.centralwidget.setEnabled(True)

class Seccion:
	"""	Clase que contiene los datos de Curso, seccion, tipo, dia, Hora
		 y profesor.
	"""
	def __init__(self,Curso,seccion,tipo,dia,Hora,Profesor):
		self.Curso=Curso
		self.seccion=seccion
		self.tipo=tipo #Teoría o práctica
		self.dia=dia
		self.Hora=Hora
		self.Profesor=Profesor
		
	def __str__(self):
		return (self.Curso.codigo+self.seccion)
	
	def mostrar_Seccion(self):
		print self.Curso.codigo,self.seccion,'\"',self.Curso.nombre,'\"',
		print self.tipo,self.dia,self.Hora.horai,"-",
		print self.Hora.horaf,self.Profesor.apellidos,",",
		print self.Profesor.nombres

class Curso:
	"""	Clase que contiene los datos de codigo,nombre y créditos de
		un curso.
	"""
	def __init__(self,codigo='',nombre='',creditos=0):
		self.codigo=codigo
		self.nombre=nombre
		self.creditos=creditos
	
	def mostrar_Curso(self):
		print self.codigo,'\"',self.nombre,'\"'

class Profesor:
	"""	Clase que contiene los apellidos y nombres de un profesor
	"""
	def __init__(self,apellidos='',nombres=''):
		self.apellidos=apellidos
		self.nombres=nombres
	
	def mostrar_Profesor(self):
		print self.apellidos,',',self.nombres

class Hora:
	"""	Clase que contiene la hora de inicio y fin de una asignatura.
	"""
	def __init__(self,horai=0,horaf=0):
		self.horai=horai
		self.horaf=horaf
	
	def mostrar_Hora(self):
		print self.horai,'-',horaf

def leer_datos(archivo,orden,tipo):
	"""	Lee el archivo csv y retorna la lista de objetos de todas las
		secciones disponibles
		
		@return: retorna una lista de los objetos Seccion encontrados.
	"""
	import os
	import codecs
	
	if os.path.exists(archivo):
		if tipo==0:
			f=codecs.open(archivo,"r",encoding='UTF-8')
		elif tipo==1:
			f=codecs.open(archivo,"r",encoding='iso-8859-1')
		
		#Captura del Orden de los campos
		l=orden
		
		#Lectura de los datos
		datos=[]
		for linea in f:
			linea=linea.replace('\'','')
			linea=linea.replace('\"','')
			datos.append(linea)

		secciones=[]
		for linea in datos:
			if len(linea)<=1:
				continue
			lista=[] #nueva seccion
			for j in linea.split(';'):
				lista.append(j.upper().strip())

			cur=Curso('','')
			hor=Hora(0,0)
			pro=Profesor('','')
			sec=Seccion(cur,'','','',hor,pro)
			
			i=0
			j=0

			while i<len(l):
			
				if l[i]==1:
					sec.Curso.codigo=lista[j]
				elif l[i]==2:
					sec.seccion=lista[j]
				elif l[i]==3:
					cur.codigo=lista[j][:-1].strip()
					sec.seccion=lista[j][-1]
				elif l[i]==4:
					cur.nombre=lista[j]
				elif l[i]==5:	
					pro.apellidos=lista[j].split(',')[0]
					pro.nombres=lista[j].split(',')[1]												
				elif l[i]==6:
					sec.dia=lista[j]
				elif l[i]==7:
					hor.horai=int(lista[j].split('-')[0])
					hor.horaf=int(lista[j].split('-')[1])
				elif l[i]==8:
					sec.dia=lista[j].split(' ')[0]
					hor.horai=int(lista[j].split(' ')[1])
					hor.horaf=int(lista[j].split(' ')[3])
				elif l[i]==9:
					hor.horai=int(lista[j])
				elif l[i]==10:
					hor.horaf=hor.horai+int(lista[j])
				elif l[i]==11:
					sec.aula=lista[j]
				elif l[i]==12:
					sec.tipo=lista[j]
				i=i+1
				j=j+1	
			
			sec.Profesor=pro
			sec.Hora=hor
			sec.Curso=cur
			
			secciones.append(sec)
		
		f.close()
		return secciones
	else:
		# No existe el archivo
		return None

def transforma_archivo_mec(archivo):
	"""	Lee el archivo txt y retorna un nuevo archivo manejable por el
		programa
		
		@return: Retorna el nombre del nuevo archivo
	"""
	import os
	import codecs
	
	if os.path.exists(archivo):
		try:
			cod='utf'
			f=codecs.open(archivo,"r",encoding='UTF-8')
			archivo2=archivo[:-4]+'_editado.csv'
			g=codecs.open(archivo2,"w",encoding='UTF-8')
			for linea in f:
				pass
		except UnicodeDecodeError:
			cod='iso'
			f=codecs.open(archivo,"r",encoding='iso-8859-1')
			archivo2=archivo[:-4]+'_editado.csv'
			g=codecs.open(archivo2,"w",encoding='iso-8859-1')
		for linea in f:
			if len(linea)<= 7 and len(linea)>=5:
				if cod=='utf':
					cur=linea
				elif cod=='iso':
					cur=linea[:-1]
			elif len(linea)>=20:
				datos=linea.split(' ')
				for sec in datos[0].split('/'):
					nueva_linea=cur[:-1]+sec+';'+datos[1]+';'+datos[2]+';'+datos[3]+';'+datos[4]+cur[-1]#+'\r'
					g.write(nueva_linea)
			else:
				pass
				
		f.close()
		g.close()
		return archivo2

def comprobar_cruze(sec,horario):
	""" @param sec: Es un objeto seccion
	
		@param horario: Lista de objetos seccion
		
		@return: La funcion retorna True si existe cruze o False si no
			lo hay.
	"""
	#Retorna True si existe cruze
	for i in horario:
		if ((i.Curso.codigo+i.seccion)==(sec.Curso.codigo+sec.seccion)) or i.Curso.codigo!=sec.Curso.codigo:
			if i.dia==sec.dia:
				for m in range(sec.Hora.horai,sec.Hora.horaf):
					for n in range(i.Hora.horai,i.Hora.horaf):
						if m==n:	# Encontró cruze
							return True
	return False

def lista_cursos(secciones):
	"""	Realiza una lista de los códigos de los cursos que aparecen en
		la lista de objetos secciones.
		
		@param secciones: Contiene la lista total de los objetos seccion
	
	"""
	from util import elimina_duplicados
	#Realizo una lista de los cursos
	cur=[]
	for i in secciones:
		cur.append(i.Curso.codigo)
	return elimina_duplicados(cur)

def lista_sec(cur,secciones):
	"""	Realizo una lista de las secciones para un curso dado
		
		@param cur: Contiene el código del curso a buscar
		
		@param secciones: Contiene la lista total de los objetos seccion		
	"""
	from util import elimina_duplicados
	
	sec=[]
	for seccion in secciones:
		if cur==seccion.Curso.codigo:
			sec.append(seccion.seccion)
	
	return elimina_duplicados(sec)
	
def buscaCurSec(cur_sec,secciones):
	"""	Encuentra todos los objetos que coincidan con el curso_seccion
		otorgado
		
		@param cur_sec: Curso-Seccion a buscar
		
		@param secciones: Lista de todos los objetos secciones
		
		@return: Entrega una lista de objetos coincidentes con la
			búsqueda.
	"""
	lista=[]
	for seccion in secciones:
		if cur_sec==(seccion.Curso.codigo+seccion.seccion):
			lista.append(seccion)
	return lista

# Main

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = Ventana()
    myapp.show()
    sys.exit(app.exec_())
